JavaScript 并发队列：掌握线程安全操作以构建可扩展应用

            const { Worker, SharedArrayBuffer, Atomics } = require('worker_threads');

const sab = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 2); // 2 integers: head and tail
const queueData = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 10); // Queue capacity of 10
const head = new Int32Array(sab, 0, 1); // Head pointer
const tail = new Int32Array(sab, Int32Array.BYTES_PER_ELEMENT, 1); // Tail pointer
const queue = new Int32Array(queueData);

Atomics.store(head, 0, 0);
Atomics.store(tail, 0, 0);

const worker = new Worker('./worker.js', { workerData: { sab, queueData } });

worker.on('message', (msg) => {
  console.log(`Message from worker: ${msg}`);
});

worker.on('error', (err) => {
  console.error(`Worker error: ${err}`);
});

worker.on('exit', (code) => {
  console.log(`Worker exited with code: ${code}`);
});

// Enqueue some data from the main thread
const enqueue = (value) => {
  const currentTail = Atomics.load(tail, 0);
  const nextTail = (currentTail + 1) % 10; // Queue size is 10
  if (nextTail === Atomics.load(head, 0)) {
    console.log("Queue is full.");
    return;
  }
  queue[currentTail] = value;
  Atomics.store(tail, 0, nextTail);
  console.log(`Enqueued ${value} from main thread`);
};

// Simulate enqueueing data
enqueue(10);
enqueue(20);

setTimeout(() => {
  enqueue(30);
}, 1000);

            

              
                Copy
              
            
          

            const { workerData } = require('worker_threads');

const { sab, queueData } = workerData;

const head = new Int32Array(sab, 0, 1);
const tail = new Int32Array(sab, Int32Array.BYTES_PER_ELEMENT, 1);
const queue = new Int32Array(queueData);

// Dequeue data from the queue
const dequeue = () => {
  const currentHead = Atomics.load(head, 0);
  if (currentHead === Atomics.load(tail, 0)) {
    return null; // Queue is empty
  }
  const value = queue[currentHead];
  const nextHead = (currentHead + 1) % 10; // Queue size is 10
  Atomics.store(head, 0, nextHead);
  return value;
};

// Simulate dequeuing data every 500ms
setInterval(() => {
  const value = dequeue();
  if (value !== null) {
    console.log(`Dequeued ${value} from worker thread`);
  }
}, 500);

            

              
                Copy
              
            
          

            class Mutex {
  constructor() {
    this.locked = false;
    this.waiting = [];
  }

  lock() {
    return new Promise((resolve) => {
      if (!this.locked) {
        this.locked = true;
        resolve();
      } else {
        this.waiting.push(resolve);
      }
    });
  }

  unlock() {
    if (this.waiting.length > 0) {
      const resolve = this.waiting.shift();
      resolve();
    } else {
      this.locked = false;
    }
  }
}

class ConcurrentQueue {
  constructor() {
    this.queue = [];
    this.mutex = new Mutex();
  }

  async enqueue(item) {
    await this.mutex.lock();
    try {
      this.queue.push(item);
      console.log(`Enqueued: ${item}`);
    } finally {
      this.mutex.unlock();
    }
  }

  async dequeue() {
    await this.mutex.lock();
    try {
      if (this.queue.length === 0) {
        return null;
      }
      const item = this.queue.shift();
      console.log(`Dequeued: ${item}`);
      return item;
    } finally {
      this.mutex.unlock();
    }
  }
}

// Example usage
const queue = new ConcurrentQueue();

async function run() {
  await Promise.all([
    queue.enqueue(1),
    queue.enqueue(2),
    queue.dequeue(),
    queue.enqueue(3),
  ]);
}

run();

            

              
                Copy
              
            
          

            const { Worker } = require('worker_threads');

const worker = new Worker('./worker.js');

// Send messages to the worker thread
worker.postMessage({ type: 'enqueue', data: 10 });
worker.postMessage({ type: 'enqueue', data: 20 });

// Receive messages from the worker thread
worker.on('message', (message) => {
  console.log(`Received message from worker: ${JSON.stringify(message)}`);
});

worker.on('error', (err) => {
  console.error(`Worker error: ${err}`);
});

worker.on('exit', (code) => {
  console.log(`Worker exited with code: ${code}`);
});

setTimeout(() => {
  worker.postMessage({ type: 'enqueue', data: 30 });
}, 1000);

            

              
                Copy
              
            
          

            const { parentPort } = require('worker_threads');

const queue = [];

// Receive messages from the main thread
parentPort.on('message', (message) => {
  switch (message.type) {
    case 'enqueue':
      queue.push(message.data);
      console.log(`Enqueued ${message.data} in worker`);
      parentPort.postMessage({ type: 'enqueued', data: message.data });
      break;
    case 'dequeue':
      if (queue.length > 0) {
        const item = queue.shift();
        console.log(`Dequeued ${item} in worker`);
        parentPort.postMessage({ type: 'dequeued', data: item });
      } else {
        parentPort.postMessage({ type: 'empty' });
      }
      break;
    default:
      console.log(`Unknown message type: ${message.type}`);
  }
});

            

              
                Copy
              
            
          

            const { Queue } = require('immutable');

let queue = Queue();

// Enqueue items
queue = queue.enqueue(10);
queue = queue.enqueue(20);

console.log(queue.toJS()); // Output: [ 10, 20 ]

// Dequeue an item
const [first, nextQueue] = queue.shift();

console.log(first); // Output: 10
console.log(nextQueue.toJS()); // Output: [ 20 ]

            

              
                Copy